home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / random.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  16.8 KB  |  487 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. from math import log as _log, exp as _exp, pi as _pi, e as _e
  5. from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  6. from math import floor as _floor
  7. __all__ = [
  8.     'Random',
  9.     'seed',
  10.     'random',
  11.     'uniform',
  12.     'randint',
  13.     'choice',
  14.     'sample',
  15.     'randrange',
  16.     'shuffle',
  17.     'normalvariate',
  18.     'lognormvariate',
  19.     'cunifvariate',
  20.     'expovariate',
  21.     'vonmisesvariate',
  22.     'gammavariate',
  23.     'stdgamma',
  24.     'gauss',
  25.     'betavariate',
  26.     'paretovariate',
  27.     'weibullvariate',
  28.     'getstate',
  29.     'setstate',
  30.     'jumpahead']
  31. NV_MAGICCONST = 4 * _exp(-0.5) / _sqrt(2.0)
  32. TWOPI = 2.0 * _pi
  33. LOG4 = _log(4.0)
  34. SG_MAGICCONST = 1.0 + _log(4.5)
  35. import _random
  36.  
  37. class Random(_random.Random):
  38.     VERSION = 2
  39.     
  40.     def __init__(self, x = None):
  41.         self.seed(x)
  42.         self.gauss_next = None
  43.  
  44.     
  45.     def seed(self, a = None):
  46.         if a is None:
  47.             import time
  48.             a = long(time.time() * 256)
  49.         
  50.         super(Random, self).seed(a)
  51.         self.gauss_next = None
  52.  
  53.     
  54.     def getstate(self):
  55.         return (self.VERSION, super(Random, self).getstate(), self.gauss_next)
  56.  
  57.     
  58.     def setstate(self, state):
  59.         version = state[0]
  60.         if version == 2:
  61.             (version, internalstate, self.gauss_next) = state
  62.             super(Random, self).setstate(internalstate)
  63.         else:
  64.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  65.  
  66.     
  67.     def __getstate__(self):
  68.         return self.getstate()
  69.  
  70.     
  71.     def __setstate__(self, state):
  72.         self.setstate(state)
  73.  
  74.     
  75.     def __reduce__(self):
  76.         return (self.__class__, (), self.getstate())
  77.  
  78.     
  79.     def randrange(self, start, stop = None, step = 1, int = int, default = None):
  80.         istart = int(start)
  81.         if istart != start:
  82.             raise ValueError, 'non-integer arg 1 for randrange()'
  83.         
  84.         if stop is default:
  85.             if istart > 0:
  86.                 return int(self.random() * istart)
  87.             
  88.             raise ValueError, 'empty range for randrange()'
  89.         
  90.         istop = int(stop)
  91.         if istop != stop:
  92.             raise ValueError, 'non-integer stop for randrange()'
  93.         
  94.         if step == 1 and istart < istop:
  95.             return int(istart + int(self.random() * (istop - istart)))
  96.         
  97.         if step == 1:
  98.             raise ValueError, 'empty range for randrange()'
  99.         
  100.         istep = int(step)
  101.         if istep != step:
  102.             raise ValueError, 'non-integer step for randrange()'
  103.         
  104.         if istep > 0:
  105.             n = ((istop - istart) + istep - 1) / istep
  106.         elif istep < 0:
  107.             n = ((istop - istart) + istep + 1) / istep
  108.         else:
  109.             raise ValueError, 'zero step for randrange()'
  110.         if n <= 0:
  111.             raise ValueError, 'empty range for randrange()'
  112.         
  113.         return istart + istep * int(self.random() * n)
  114.  
  115.     
  116.     def randint(self, a, b):
  117.         return self.randrange(a, b + 1)
  118.  
  119.     
  120.     def choice(self, seq):
  121.         return seq[int(self.random() * len(seq))]
  122.  
  123.     
  124.     def shuffle(self, x, random = None, int = int):
  125.         if random is None:
  126.             random = self.random
  127.         
  128.         for i in xrange(len(x) - 1, 0, -1):
  129.             j = int(random() * (i + 1))
  130.             (x[i], x[j]) = (x[j], x[i])
  131.         
  132.  
  133.     
  134.     def sample(self, population, k):
  135.         n = len(population)
  136.         if not None if k <= k else k <= n:
  137.             raise ValueError, 'sample larger than population'
  138.         
  139.         random = self.random
  140.         _int = int
  141.         result = [
  142.             None] * k
  143.         if n < 6 * k:
  144.             pool = list(population)
  145.             for i in xrange(k):
  146.                 j = _int(random() * (n - i))
  147.                 result[i] = pool[j]
  148.                 pool[j] = pool[n - i - 1]
  149.             
  150.         else:
  151.             
  152.             try:
  153.                 if n > 0:
  154.                     pass
  155.                 (population[0], population[n // 2], population[n - 1])
  156.             except (TypeError, KeyError):
  157.                 population = tuple(population)
  158.  
  159.             selected = { }
  160.             for i in xrange(k):
  161.                 j = _int(random() * n)
  162.                 while j in selected:
  163.                     j = _int(random() * n)
  164.                 result[i] = selected[j] = population[j]
  165.             
  166.         return result
  167.  
  168.     
  169.     def uniform(self, a, b):
  170.         return a + (b - a) * self.random()
  171.  
  172.     
  173.     def normalvariate(self, mu, sigma):
  174.         random = self.random
  175.         while True:
  176.             u1 = random()
  177.             u2 = 1.0 - random()
  178.             z = NV_MAGICCONST * (u1 - 0.5) / u2
  179.             zz = z * z / 4.0
  180.             if zz <= -_log(u2):
  181.                 break
  182.                 continue
  183.         return mu + z * sigma
  184.  
  185.     
  186.     def lognormvariate(self, mu, sigma):
  187.         return _exp(self.normalvariate(mu, sigma))
  188.  
  189.     
  190.     def cunifvariate(self, mean, arc):
  191.         import warnings
  192.         warnings.warn('The cunifvariate function is deprecated; Use (mean + arc * (Random.random() - 0.5)) % Math.pi instead.', DeprecationWarning, 2)
  193.         return (mean + arc * (self.random() - 0.5)) % _pi
  194.  
  195.     
  196.     def expovariate(self, lambd):
  197.         random = self.random
  198.         u = random()
  199.         while u <= 9.9999999999999995e-008:
  200.             u = random()
  201.         return -_log(u) / lambd
  202.  
  203.     
  204.     def vonmisesvariate(self, mu, kappa):
  205.         random = self.random
  206.         if kappa <= 9.9999999999999995e-007:
  207.             return TWOPI * random()
  208.         
  209.         a = 1.0 + _sqrt(1.0 + 4.0 * kappa * kappa)
  210.         b = (a - _sqrt(2.0 * a)) / (2.0 * kappa)
  211.         r = (1.0 + b * b) / (2.0 * b)
  212.         while True:
  213.             u1 = random()
  214.             z = _cos(_pi * u1)
  215.             f = (1.0 + r * z) / (r + z)
  216.             c = kappa * (r - f)
  217.             u2 = random()
  218.             if u2 >= c * (2.0 - c):
  219.                 pass
  220.             if not (u2 > c * _exp(1.0 - c)):
  221.                 break
  222.                 continue
  223.         u3 = random()
  224.         if u3 > 0.5:
  225.             theta = mu % TWOPI + _acos(f)
  226.         else:
  227.             theta = mu % TWOPI - _acos(f)
  228.         return theta
  229.  
  230.     
  231.     def gammavariate(self, alpha, beta):
  232.         if alpha <= 0.0 or beta <= 0.0:
  233.             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
  234.         
  235.         random = self.random
  236.         if alpha > 1.0:
  237.             ainv = _sqrt(2.0 * alpha - 1.0)
  238.             bbb = alpha - LOG4
  239.             ccc = alpha + ainv
  240.             while True:
  241.                 u1 = random()
  242.                 if not None if u1 < u1 else u1 < 0.99999990000000005:
  243.                     continue
  244.                 
  245.                 u2 = 1.0 - random()
  246.                 v = _log(u1 / (1.0 - u1)) / ainv
  247.                 x = alpha * _exp(v)
  248.                 z = u1 * u1 * u2
  249.                 r = bbb + ccc * v - x
  250.                 if r + SG_MAGICCONST - 4.5 * z >= 0.0 or r >= _log(z):
  251.                     return x * beta
  252.                     continue
  253.         elif alpha == 1.0:
  254.             u = random()
  255.             while u <= 9.9999999999999995e-008:
  256.                 u = random()
  257.             return -_log(u) * beta
  258.         else:
  259.             while True:
  260.                 u = random()
  261.                 b = (_e + alpha) / _e
  262.                 p = b * u
  263.                 if p <= 1.0:
  264.                     x = pow(p, 1.0 / alpha)
  265.                 else:
  266.                     x = -_log((b - p) / alpha)
  267.                 u1 = random()
  268.                 if p <= 1.0 and u1 > _exp(-x) and p > 1:
  269.                     pass
  270.                 if not (u1 > pow(x, alpha - 1.0)):
  271.                     break
  272.                     continue
  273.             return x * beta
  274.  
  275.     
  276.     def stdgamma(self, alpha, ainv, bbb, ccc):
  277.         import warnings
  278.         warnings.warn('The stdgamma function is deprecated; use gammavariate() instead.', DeprecationWarning, 2)
  279.         return self.gammavariate(alpha, 1.0)
  280.  
  281.     
  282.     def gauss(self, mu, sigma):
  283.         random = self.random
  284.         z = self.gauss_next
  285.         self.gauss_next = None
  286.         if z is None:
  287.             x2pi = random() * TWOPI
  288.             g2rad = _sqrt(-2.0 * _log(1.0 - random()))
  289.             z = _cos(x2pi) * g2rad
  290.             self.gauss_next = _sin(x2pi) * g2rad
  291.         
  292.         return mu + z * sigma
  293.  
  294.     
  295.     def betavariate(self, alpha, beta):
  296.         y = self.gammavariate(alpha, 1.0)
  297.         if y == 0:
  298.             return 0.0
  299.         else:
  300.             return y / (y + self.gammavariate(beta, 1.0))
  301.  
  302.     
  303.     def paretovariate(self, alpha):
  304.         u = 1.0 - self.random()
  305.         return 1.0 / pow(u, 1.0 / alpha)
  306.  
  307.     
  308.     def weibullvariate(self, alpha, beta):
  309.         u = 1.0 - self.random()
  310.         return alpha * pow(-_log(u), 1.0 / beta)
  311.  
  312.  
  313.  
  314. class WichmannHill(Random):
  315.     VERSION = 1
  316.     
  317.     def seed(self, a = None):
  318.         if a is None:
  319.             import time
  320.             a = long(time.time() * 256)
  321.         
  322.         if not isinstance(a, (int, long)):
  323.             a = hash(a)
  324.         
  325.         (a, x) = divmod(a, 30268)
  326.         (a, y) = divmod(a, 30306)
  327.         (a, z) = divmod(a, 30322)
  328.         self._seed = (int(x) + 1, int(y) + 1, int(z) + 1)
  329.         self.gauss_next = None
  330.  
  331.     
  332.     def random(self):
  333.         (x, y, z) = self._seed
  334.         x = 171 * x % 30269
  335.         y = 172 * y % 30307
  336.         z = 170 * z % 30323
  337.         self._seed = (x, y, z)
  338.         return (x / 30269.0 + y / 30307.0 + z / 30323.0) % 1.0
  339.  
  340.     
  341.     def getstate(self):
  342.         return (self.VERSION, self._seed, self.gauss_next)
  343.  
  344.     
  345.     def setstate(self, state):
  346.         version = state[0]
  347.         if version == 1:
  348.             (version, self._seed, self.gauss_next) = state
  349.         else:
  350.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  351.  
  352.     
  353.     def jumpahead(self, n):
  354.         if not (n >= 0):
  355.             raise ValueError('n must be >= 0')
  356.         
  357.         (x, y, z) = self._seed
  358.         x = int(x * pow(171, n, 30269)) % 30269
  359.         y = int(y * pow(172, n, 30307)) % 30307
  360.         z = int(z * pow(170, n, 30323)) % 30323
  361.         self._seed = (x, y, z)
  362.  
  363.     
  364.     def __whseed(self, x = 0, y = 0, z = 0):
  365.         if not None if type(y) == type(y) and type(z) == type(z) else type(z) == int:
  366.             raise TypeError('seeds must be integers')
  367.         
  368.         if x <= x:
  369.             pass
  370.         elif x < 256:
  371.             if y <= y:
  372.                 pass
  373.             elif y < 256:
  374.                 pass
  375.         if not None if z <= z else z < 256:
  376.             raise ValueError('seeds must be in range(0, 256)')
  377.         
  378.         if x == x and y == y:
  379.             pass
  380.         elif y == z:
  381.             import time
  382.             t = long(time.time() * 256)
  383.             t = int(t & 16777215 ^ t >> 24)
  384.             (t, x) = divmod(t, 256)
  385.             (t, y) = divmod(t, 256)
  386.             (t, z) = divmod(t, 256)
  387.         
  388.         if not x:
  389.             pass
  390.         if not y:
  391.             pass
  392.         if not z:
  393.             pass
  394.         self._seed = (1, 1, 1)
  395.         self.gauss_next = None
  396.  
  397.     
  398.     def whseed(self, a = None):
  399.         if a is None:
  400.             self._WichmannHill__whseed()
  401.             return None
  402.         
  403.         a = hash(a)
  404.         (a, x) = divmod(a, 256)
  405.         (a, y) = divmod(a, 256)
  406.         (a, z) = divmod(a, 256)
  407.         if not (x + a) % 256:
  408.             pass
  409.         x = 1
  410.         if not (y + a) % 256:
  411.             pass
  412.         y = 1
  413.         if not (z + a) % 256:
  414.             pass
  415.         z = 1
  416.         self._WichmannHill__whseed(x, y, z)
  417.  
  418.  
  419.  
  420. def _test_generator(n, funccall):
  421.     import time
  422.     print n, 'times', funccall
  423.     code = compile(funccall, funccall, 'eval')
  424.     total = 0.0
  425.     sqsum = 0.0
  426.     smallest = 10000000000.0
  427.     largest = -10000000000.0
  428.     t0 = time.time()
  429.     for i in range(n):
  430.         x = eval(code)
  431.         total += x
  432.         sqsum = sqsum + x * x
  433.         smallest = min(x, smallest)
  434.         largest = max(x, largest)
  435.     
  436.     t1 = time.time()
  437.     print round(t1 - t0, 3), 'sec,',
  438.     avg = total / n
  439.     stddev = _sqrt(sqsum / n - avg * avg)
  440.     print 'avg %g, stddev %g, min %g, max %g' % (avg, stddev, smallest, largest)
  441.  
  442.  
  443. def _test(N = 2000):
  444.     _test_generator(N, 'random()')
  445.     _test_generator(N, 'normalvariate(0.0, 1.0)')
  446.     _test_generator(N, 'lognormvariate(0.0, 1.0)')
  447.     _test_generator(N, 'cunifvariate(0.0, 1.0)')
  448.     _test_generator(N, 'vonmisesvariate(0.0, 1.0)')
  449.     _test_generator(N, 'gammavariate(0.01, 1.0)')
  450.     _test_generator(N, 'gammavariate(0.1, 1.0)')
  451.     _test_generator(N, 'gammavariate(0.1, 2.0)')
  452.     _test_generator(N, 'gammavariate(0.5, 1.0)')
  453.     _test_generator(N, 'gammavariate(0.9, 1.0)')
  454.     _test_generator(N, 'gammavariate(1.0, 1.0)')
  455.     _test_generator(N, 'gammavariate(2.0, 1.0)')
  456.     _test_generator(N, 'gammavariate(20.0, 1.0)')
  457.     _test_generator(N, 'gammavariate(200.0, 1.0)')
  458.     _test_generator(N, 'gauss(0.0, 1.0)')
  459.     _test_generator(N, 'betavariate(3.0, 3.0)')
  460.  
  461. _inst = Random()
  462. seed = _inst.seed
  463. random = _inst.random
  464. uniform = _inst.uniform
  465. randint = _inst.randint
  466. choice = _inst.choice
  467. randrange = _inst.randrange
  468. sample = _inst.sample
  469. shuffle = _inst.shuffle
  470. normalvariate = _inst.normalvariate
  471. lognormvariate = _inst.lognormvariate
  472. cunifvariate = _inst.cunifvariate
  473. expovariate = _inst.expovariate
  474. vonmisesvariate = _inst.vonmisesvariate
  475. gammavariate = _inst.gammavariate
  476. stdgamma = _inst.stdgamma
  477. gauss = _inst.gauss
  478. betavariate = _inst.betavariate
  479. paretovariate = _inst.paretovariate
  480. weibullvariate = _inst.weibullvariate
  481. getstate = _inst.getstate
  482. setstate = _inst.setstate
  483. jumpahead = _inst.jumpahead
  484. if __name__ == '__main__':
  485.     _test()
  486.  
  487.